home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 19 / Mac Magazin and MacEasy Magazine CD - Issue 19.iso / Wissenschaft & Technik / chipmunk-basic-321 ƒ / basic.man next >
Text File  |  1995-08-13  |  21KB  |  801 lines

  1.     BASIC(1)        chipmunk-basic v3.2             BASIC(1)
  2.  
  3.  
  4.     Chipmunk BASIC - 'BASIC' language interpreter
  5.     
  6.  
  7.     SYNOPSIS    ( UNIX )
  8.  
  9.     basic [ filename ]
  10.  
  11.     DESCRIPTION
  12.  
  13.     Chipmunk basic is an interpreter for the BASIC language. If a
  14.     filename parameter is given, then the named program file is
  15.     loaded and run as a Basic program.  
  16.  
  17.     Basic commands and statements can be entered and interpreted in
  18.     immediate mode or executed as program statements when the Basic
  19.     program is run.  A built-in line number based editor allows
  20.     program input from the console keyboard.  See below for the
  21.     commands the interpreter recognizes.
  22.     
  23.     FLAGS
  24.  
  25.     none
  26.  
  27.     COMMANDS
  28.         
  29.     Standard mumbleSoft-like Basic Commands:
  30.  
  31.     load STRINGEXPR
  32.  
  33.         Load a program into memory from the named file. The
  34.         program previously in memory is erased.  All
  35.         variables are cleared.  All lines in the file must
  36.         begin with a line number.  Line numbers do not
  37.         need to be in increasing order.
  38.  
  39.  
  40.     save STRINGEXPR
  41.  
  42.         Save the current program to a named file.
  43.  
  44.     new
  45.  
  46.         Erase the program in memory.  All files are closed and
  47.         all variables are cleared.
  48.  
  49.     clear
  50.  
  51.         All  variables are cleared.  All arrays and string
  52.         variables are deallocated.
  53.  
  54.     run { LINENUM }
  55.     run { STRINGEXPR { , LINENUM } }
  56.  
  57.         Begin execution of the program at the first line, or at
  58.         the specified line.  All variables are cleared.  If a
  59.         STRINGEXPR is given then the BASIC program with that name
  60.         file is loaded into memory first.  Program lines are
  61.         executed in line number order.
  62.  
  63.     cont
  64.  
  65.         CONTinue execution of the program on the next statement
  66.         after the statement on which the program stopped execution
  67.         due to a STOP command or an error.  See BUGS section.
  68.  
  69.     goto LINENUM
  70.  
  71.         This statement will transfer control to the line number
  72.         specified.  If the program is not running, then this
  73.         command will begin execution at the specified line
  74.         without clearing the variables.  An "Undefined line"
  75.         error will occur if LINENUM doesn't exist in the program.
  76.  
  77.     list
  78.         List the whole program.
  79.  
  80.     list 1-3
  81.         List lines 1 to 2
  82.  
  83.     list -2
  84.         List lines up to 1
  85.  
  86.     list 1
  87.         List line 1
  88.     
  89.     list 2-
  90.         List lines from 2 on
  91.  
  92.     merge STRINGEXPR
  93.  
  94.         Load a program into memory.  The previous program
  95.         remains in memory; if a line exists in both programs,
  96.         the newly loaded line is kept.
  97.  
  98.     renum STRINGEXPR VAL { , VAL { , VAL { , VAL} } }
  99.  
  100.         Renumber program lines.  By default, the new sequence
  101.         is 10,20,30,... The first argument is a new initial
  102.         line number; the second argument is the increment
  103.         between line numbers. The third and fourth arguments,
  104.         if present, specify a limiting range of old line numbers
  105.         to renumber.  RENUM can be used to move non-overlapping
  106.         blocks of code.
  107.      
  108.     edit LINENUM
  109.  
  110.         Edit a given line. If the exit from the edit is via a
  111.         cntrl-c then do not change the line.
  112.             i    insert till <return>
  113.             x    delete one char
  114.             A    append to end of line
  115.  
  116.     delete LINENUM - LINENUM
  117.  
  118.         Delete a specified range of lines. If not found then no
  119.         lines will be deleted.  If used inside a program, DEL
  120.         will terminate execution only if it deletes the line on
  121.         which it appears.
  122.  
  123.     exit
  124.     bye
  125.     quit
  126.  
  127.         Terminates the basic interpreter, ending program
  128.         execution and closing all files.
  129.  
  130.  
  131.     STATEMENTS
  132.  
  133.     { let } VAR = EXPR
  134.  
  135.         Assign a value to a variable.  Variable names can be up
  136.         to 31 significant characters, consisting of letters,
  137.         digits, underscores, and an ending dollar sign. 
  138.         Variable names are case insensitive.  Variables can
  139.         hold real numbers (IEEE double) or strings of up
  140.         to 254 characters.  If the variable name ends with a
  141.         "$" it holds strings, otherwise it holds numbers.  If a
  142.         statement starts with a variable name then an implied
  143.         LET is assumed.
  144.  
  145.     print or '?' VAL | STRINGVAL { [ , | ; ] VAL ... } { ; }
  146.     print #FNUM, VAL ...
  147.  
  148.         This command will print its parameters tab delimited.
  149.         If a semi-colon is used between parameters then no tab
  150.         is inserted between the parameters.  The print
  151.         output is terminated with a carriage return unless the
  152.         parameter list ends with a semi-colon.  If a file
  153.         descriptor is given then output is redirected to the
  154.         given file.  If a
  155.         
  156.             tab(VAL);
  157.             
  158.         is found in a print statement, then print output will
  159.         skip to the horizontal position specified by VAL.
  160.  
  161.     print { #FNUM, } using STRINGVAL ; VAR { [ , | ; ] VAR ... }
  162.     
  163.         Prints formatted numbers.  Legal characters for the
  164.         format string are: + * $ # . and trailing spaces.
  165.         
  166.         Examples:
  167.         
  168.             print using "**$###.##"; 1.23    ->  ****$1.23
  169.             print using "###.##"; 2.12345    ->    2.12
  170.             
  171.     
  172.     input { # FNUM , } { STRINGVAR | VAR { , VAR } }
  173.  
  174.     input "prompt"; { STRINGVAR | VAR  { , VAR } }
  175.  
  176.         Input from a terminal or from a file. If the input is
  177.         from the terminal then a prompt message can also be
  178.         added.
  179.         
  180.         All input to string variables is "line input"; a whole
  181.         input line will be read into one string variable.  This
  182.         usage is different from other versions Basic.
  183.  
  184.     get STRINGVAR
  185.     
  186.         Gets one character from the console keyboard.  Blocking.
  187.     
  188.     cls
  189.         Clear the terminals screen.  Leaves the cursor in the
  190.         upper left corner.  For Applesoft BASIC fans, the "home"
  191.         command will also do this.
  192.  
  193.     end
  194.  
  195.         Terminates program execution and returns to the command
  196.         prompt.  Not required.
  197.  
  198.     stop
  199.  
  200.         Stops the execution of the program and returns to
  201.         the command prompt.  Prints a "Break..." message.
  202.  
  203.     if EXPR then STATEMENT { : STATEMENT } { : else STATEMENT }
  204.     if EXPR then LINENUM
  205.     if EXPR
  206.  
  207.         The IF statement.  If the condition is true then the
  208.         STATEMENTS after the THEN are executed and the
  209.         statements after the ELSE are skipped.  If the
  210.         condition is false then the statements after the "else"
  211.         are executed instead.  If the item after "then" is a
  212.         line number then a goto is executed.
  213.         
  214.         If the condition is true and there is no THEN on the
  215.         same line, statements are executed until a line
  216.         with an ENDIF is found.  (block IF() ... ENDIF)
  217.  
  218.     for VAR = EXPR to EXPR { step EXPR }
  219.  
  220.         Beginning of a "for next" loop.  It takes a starting
  221.         value, a limit and an optional step argument.  If the
  222.         step value is negative, the variable counts down.  The
  223.         body of the loop is not executed if the end condition
  224.         is true initially.
  225.  
  226.         Example:
  227.             for i=1 to 10 : print i, : next i
  228.             rem prints the numbers from 1 through 10
  229.  
  230.     next { VAR }
  231.  
  232.         End of a "for next" loop.  If the termination
  233.         conditions are met then execution falls through to the
  234.         following statement, otherwise execution returns to the
  235.         statement following the corresponding "for" statement.
  236.         The "next" does not need a variable name parameter.  If
  237.         this is the case the innermost "for" loop is used.
  238.  
  239.     while { EXPR }
  240.  
  241.         Start of a WHILE loop. The loop is repeated until EXPR
  242.         is false. If EXPR is false at loop entry, then the loop
  243.         is not executed at all. A WHILE loop must be
  244.         terminated by a WEND statement.
  245.  
  246.     wend { EXPR }
  247.  
  248.         Terminating statement of a WHILE loop.  If EXPR is true
  249.         then exit the loop.  Only one WEND is allowed for each
  250.         WHILE.  A WHILE-WEND loop without a condition will loop
  251.         forever.
  252.  
  253.     gosub LINENUM
  254.  
  255.         Transfer command to a line number. Save return address
  256.         so that the program can resume execution at the
  257.         statement after the "gosub" command.  The recursion
  258.         depth is limited only by available memory.
  259.  
  260.     return
  261.  
  262.         Returns from the most recently activated subroutine
  263.         call (must have been called by gosub).
  264.  
  265.     on EXPR   goto  LINENUM { , LINENUM ... }
  266.     on EXPR   gosub LINENUM { , LINENUM ... }
  267.     on error goto  LINENUM
  268.  
  269.         This command will execute either a goto or a gosub to
  270.         the specified line number indexed by the value of EXPR.
  271.         
  272.         If the error form is used, only one linenumber is
  273.         allowed.  LINENUM is the line to which control is
  274.         transferred if an error occurs.  A GOTO or CONT statement
  275.         can be used to resume execution.  An error inside a named
  276.         SUB subroutine cannot be resumed from or CONTinued.
  277.  
  278.     sub NAME ( VAR { , VAR ... } }
  279.  
  280.         Subroutine entry.  May be called by a CALL statement or
  281.         by NAME. A SUB subroutine must be exited by a RETURN or
  282.         END SUB statement.  There should be only one RETURN or
  283.         END SUB statement per SUB subroutine.  The variables in
  284.         the VAR list become local variables. String and numeric
  285.         arguments are passed by value; array arguments must be
  286.         pre-dimensioned and are passed by reference.
  287.         
  288.         Example:
  289.             110  x = foo (7, j) : rem Pass 7 and j by value.
  290.             ...
  291.             2000 sub foo (x,y,z) : rem z is a local variable
  292.             2010   print x       : rem prints 7 the first time
  293.             2090 return (y+1)    : rem also restores x,y,z
  294.  
  295.  
  296.     select case EXPR
  297.     
  298.         Multi-way branch.  Executes the statements after the CASE
  299.         statement which matches the SELECT CASE expression, then
  300.         skips to the END SELECT statement.  If these is no match,
  301.         and a CASE ELSE statement is present, then execution defaults
  302.         to the statements following the CASE ELSE.
  303.         
  304.         Example:
  305.             200 select case x
  306.             210   case 2
  307.             ...
  308.             230   case 3, 4
  309.             ...
  310.             270   case else
  311.             ...
  312.             290 end select
  313.  
  314.  
  315.     dim VAR( d { , d { , d } } ) { , VAR( d { , d { , d } } ) }
  316.  
  317.         Dimension an array or list of arrays (string or numeric). 
  318.         A maximum of 4 dimensions can be used. The maximum
  319.         dimension size is limited by available memory. Legal
  320.         array subscripts are from 0 up and including the
  321.         dimension specified; d+1 elements are allocated.  All
  322.         arrays must be dimensioned before use.
  323.         
  324.         Example:
  325.             10 dim a(10)
  326.             20 for i=0 to 10
  327.             30   a(i) = i^2
  328.             40 next i
  329.             50 print a(5) : rem should print 25
  330.  
  331.     read VAR { , VAR }
  332.  
  333.         Read data from the DATA statements contained in the
  334.         program. List items can be either string or numeric
  335.         variables. Reading past the end the last DATA statement
  336.         generates an error.
  337.  
  338.     data ITEM { , ITEM }
  339.  
  340.         DATA statements contain the data used in the READ
  341.         statements. Items must be separated by commas.  The
  342.         items may be either numeric or string expressions,
  343.         corresponding to the type of variable being read.
  344.         Reading the wrong kind of object produces a "Type
  345.         mismatch" error.
  346.  
  347.     restore { LINENUM }
  348.  
  349.         The RESTORE statement causes the next READ to use the
  350.         first DATA statement in the program.  If a LINENUM is
  351.         given then the DATA statement on or after that
  352.         particular line is used next.
  353.  
  354.     rem or "`"
  355.  
  356.         A remark or comment statement.  Ignored by the program
  357.         during execution, however a REM statement can be the
  358.         target of a GOTO or GOSUB.
  359.  
  360.     open STRINGEXPR for { input|output|append } as # FNUM
  361.  
  362.         Open a file. The { input|output|append } parameter
  363.         specifies whether the file is to be read, written or
  364.         appended.  If STRINGEXPR is "stdin" for input or
  365.         "stdout" for output then the console will be used
  366.         instead of a file.  A "file not found" error will
  367.         occur if a non-existant file is specified in an OPEN
  368.         for input statement.
  369.  
  370.     close # FNUM
  371.  
  372.         Close a file. Releases the file descriptor and flushes
  373.         out all stored data.
  374.  
  375.     def fnNAME ( VAR { , VAR } ) = EXPR
  376.  
  377.         Define a user definable function.
  378.         
  379.         Example:
  380.             10 def fnplus(x,y) = x+y
  381.             20 print fnplus(3,5) : rem prints 8
  382.  
  383.     { let } mid$( STRINGVAR, EXPR1, EXPR2 ) = STRINGEXPR
  384.  
  385.         Insert STRINGEXPR into STRINGVAR starting at EXPR1 
  386.         for character length EXPR2.
  387.  
  388.     exec(STRINGEXPR)
  389.  
  390.         Executes STRINGEXPR as a statement or command. 
  391.         e.g. exec("print " + "x") will print the value of x.
  392.  
  393.     poke ADDR_EXPR, DATA_EXPR
  394.  
  395.         Poke a byte into a memory location. Unreasonable
  396.         addresses can cause bus-errors.
  397.  
  398.     push VAR { , VAR ... }
  399.  
  400.         Pushes one or more expressions or variables onto an
  401.         internal stack.  Expressions can be returned using the
  402.         POP function; variables can be returned by using the
  403.         POP statement.
  404.     
  405.     pop VAL
  406.  
  407.         POP statement (see also POP function). Pops VAL
  408.         variables off the internal stack, restoring the value
  409.         of those variables to their pushed values.
  410.     
  411.     NUMERIC FUNCTIONS
  412.  
  413.     sgn(VAL)
  414.  
  415.         Returns the sign of the parameter value.  Returns 1 if
  416.         the value is greater than zero , zero if equal to zero.
  417.         -1 if negative.
  418.  
  419.     abs(x)
  420.  
  421.         Returns the absolute value of x.
  422.  
  423.     int(x)
  424.  
  425.         Returns the integer value of x.  Truncates toward zero.
  426.  
  427.     sqr(x)
  428.  
  429.         Returns the square root of x.
  430.  
  431.     log(x)
  432.  
  433.         Returns the natural logarithm of x.
  434.  
  435.     exp(x)
  436.  
  437.         Returns e^x. e=2.7182818...
  438.  
  439.     sin(x)
  440.     cos(x)
  441.     atn(x)
  442.  
  443.         Trigonometric functions: sin, cosine and arctangent. 
  444.  
  445.     pi
  446.     
  447.         Returns pi, 3.14159265358979323... 
  448.  
  449.     rnd ( EXPR )
  450.  
  451.         Returns a random number between 0 and int(EXPR)-1 inclusive.
  452.         If EXPR is 1, then returns a fraction between 0 and 1.
  453.         If EXPR is negative then EXPR seeds the random number
  454.         generator.
  455.  
  456.     randomize EXPR
  457.  
  458.         Seeds the random number generator with the integer EXPR.
  459.  
  460.     len(STRINGEXPR)
  461.  
  462.         Returns the length of the string STRINGEXPR.
  463.  
  464.     val(STRINGEXPR)
  465.  
  466.         Value of the expression contained in STRINGEXPR.
  467.         STRINGEXPR may be a string literal, variable, function,
  468.         or expression.
  469.         
  470.         For example, VAL("1+sqr(4)") yields 3.
  471.  
  472.     asc(STRINGEXPR)
  473.  
  474.         Returns the ascii code for the first character of
  475.         STRINGEXPR.  A null string returns zero.
  476.  
  477.     instr(a$, b$ { , VAL } )
  478.  
  479.         Returns the position of the substring b$ in the string a$
  480.         or returns a zero if b$ is not a substring.
  481.         VAL is an optional starting position in a$
  482.  
  483.     eof(FILENUM)
  484.  
  485.         Returns true if the file specified by FILENUM has reached
  486.         the end of the file.
  487.  
  488.     pop
  489.  
  490.         POP function (see also POP statement). Pops one variable
  491.         value off the stack and returns that value (string or
  492.         numeric).
  493.         
  494.         (POP can be used as either a statement (with a
  495.         parameter) or a function (no parameter). Note that the
  496.         POP function, unlike the POP statement, does not
  497.         restore the value of the variable pushed, but only
  498.         returns the pushed value.  This use of the POP
  499.         statement is different from the Applesoft usage.)
  500.  
  501.     peek( ADDR { , VAL } )
  502.  
  503.         Returns the value of the byte in memory at address ADDR.
  504.         If VAL is 2 or 4, returns the value of the 16-bit or
  505.         32-bit word respectively (if correctly aligned).
  506.         If VAL is 8, returns the value of the numeric variable
  507.         located at ADDR.  peek(varptr(x),8) equals x.
  508.  
  509.     varptr( VAR | STRINGVAR )
  510.     
  511.         Returns the memory address of a variable.
  512.     
  513.     erl
  514.  
  515.         Returns the line number of the last error.  Zero if the
  516.         error was in immediate mode.  The variable errorstatus$
  517.         gives the error type.
  518.  
  519.     timer
  520.  
  521.         Returns a numeric value of elapsed of seconds from the
  522.         computers internal clock.
  523.  
  524.     
  525.     STRING FUNCTIONS
  526.  
  527.     x$ + y$
  528.  
  529.         String concatenation.  Result must be 254 characters or less.
  530.     
  531.     chr$(VAL)
  532.  
  533.         Returns the ascii character corresponding to the value
  534.         of VAL.
  535.  
  536.     str$( VAL { , EXPR } )
  537.  
  538.         Returns a string representation corresponding to VAL.
  539.         If EXPR is present then the string is padded to that
  540.         length.
  541.  
  542.     inkey$
  543.  
  544.         Return one character from the keyboard if input is
  545.         available. Returns a zero length string { "" } if no
  546.         keyboard input is available.  Non-blocking.  Can be used
  547.         for keyboard polling.
  548.  
  549.     input$( EXPR { , FILENUM } )
  550.  
  551.         Returns EXPR characters from file FILENUM. If f is not
  552.         present then get input from the console keyboard.
  553.  
  554.     mid$( a$, i { , j } )
  555.  
  556.         Returns a substring of a$ starting at the i'th
  557.         positions and j characters in length. If the second
  558.         parameter is not specified then the substring is taken
  559.         from the start position to the end of a$.
  560.  
  561.     right$(a$, EXPR )
  562.  
  563.         Returns the right EXPR characters of a$.
  564.  
  565.     left$(a$, EXPR )
  566.  
  567.         Returns the left EXPR characters of a$.
  568.  
  569.     field$( STRINGVAL, VAL { , STRINGVAL } )
  570.  
  571.         Returns the n-th field of the first string.  If the
  572.         optional string is present then use the first character
  573.         of that string as the field separator.  The default
  574.         separator is a space.  Similar to UNIX 'awk' fields.
  575.         
  576.         e.g.  field$("11 22 33 44", 3)  returns  "33"
  577.  
  578.     hex$( VAL { , EXPR } )
  579.     bin$( VAL { , EXPR } )
  580.  
  581.         Returns the hexadecimal or binary string representation
  582.         corresponding to VAL.  If EXPR is present then the
  583.         string is padded with zeros to make it that length.
  584.  
  585.     lcase$( STRINGVAL )
  586.  
  587.         Returns STRINGVAL in all lower case characters.
  588.  
  589.     errorstatus$
  590.  
  591.         Returns the error message for the last error.
  592.  
  593.  
  594.     OPERATORS
  595.  
  596.     The following mathematical operators  are available:
  597.  
  598.         ^    exponentiation
  599.         *    multiplication
  600.         /    division
  601.         mod    remainder
  602.         +    addition
  603.         -    subtraction
  604.  
  605.     logical operators: (any non-zero value is true)
  606.  
  607.             not    logical not
  608.  
  609.     bitwise operators:
  610.  
  611.             and    bitwise and
  612.             or    bitwise or
  613.             xor    bitwise exclusive-or
  614.  
  615.     comparison operators:
  616.  
  617.             <=    less than or equal
  618.             <>    not equal to
  619.             >=    greater than or equal
  620.             =    equal
  621.             >    greater than
  622.             <    less than
  623.  
  624.     x$=y$, x$<y$, x$>y$, x$<=y$, x$>=y$, x$<>y$
  625.  
  626.         String comparisons; result is 1 if true, 0 if false.
  627.         
  628.     Operator precedence (highest to lowest):
  629.  
  630.         ( )
  631.         not -{unary_minus} functions
  632.         ^
  633.         * / mod
  634.         + -
  635.         = < > <= >= <>
  636.         and
  637.         or xor
  638.  
  639.     
  640.     UNIX commands and functions:
  641.  
  642.     sys( STRINGVAL )
  643.  
  644.         UNIX system call.  The string parameter is given to
  645.         the shell as a command.
  646.  
  647.     argv$
  648.         Returns the UNIX shell command line arguments.
  649.  
  650.  
  651.     Macintosh commands:
  652.  
  653.     gotoxy VAL, VAL
  654.  
  655.         Set the horizontal and vertical location of the
  656.         text output cursor.  (0,0) is the upper left corner.
  657.  
  658.     moveto VAL, VAL
  659.  
  660.         Sets the (x,y) location of the graphics pen.
  661.  
  662.     lineto VAL, VAL
  663.  
  664.         Draws a line from the current pen location to location
  665.         (x,y) in the graphics window.
  666.  
  667.     window x, y, char_cols, char_lines
  668.  
  669.         Change the text console window position and size.
  670.  
  671.     morse STRINGVAL { , VAL, VAL, VAL, VAL }
  672.  
  673.         Plays morse code through the speaker.
  674.         The parameters are { dot-speed-wpm, volume{0..100},
  675.         word-speed-wpm, frequency_cps }
  676.  
  677.     sound VAL, VAL, VAL 
  678.  
  679.         The parameters are
  680.         { frequency_cps, seconds_duration, volume{0..100} }
  681.     
  682.     say STRINGVAL
  683.  
  684.         Speaks STRINGVAL if the Speech Manager Extension is
  685.         resident.  Try "say a$,200,46,1" for faster speech.
  686.  
  687.     open "SFGetFile" for input  as #FNUM
  688.     open "SFPutFile" for output as #FNUM
  689.  
  690.         Puts up a standard file dialog for the file name.
  691.  
  692.     files { STRINGVAL }
  693.     
  694.         Displays a listing of files in the named or current
  695.         directory.
  696.     
  697.     Macintosh functions:
  698.     
  699.     fre
  700.         Returns the amount of memory left for program use. 
  701.     
  702.     date$
  703.         Returns a string corresponding to the current date.
  704.  
  705.     time$
  706.         Returns a string corresponding to the current time.
  707.  
  708.     pos(VAL)
  709.  
  710.         Returns the horizontal position of the text cursor.
  711.         If VAL is negative returns the vertical position.
  712.     
  713.     errorstatus$
  714.     
  715.         Also returns the full path name of the program and
  716.         files opened by SFGetFile. (under System 7 and only
  717.         if the name fits in a string variable)
  718.     
  719.     
  720.     Macintosh menu items:
  721.  
  722.     Open or <cmd>O     will put up a dialog to allow selection
  723.             of a program file to load.  Basic Program file
  724.             names must end with a ".bas" suffix.
  725.  
  726.     Copy        will allow copying picts from the graphics
  727.             window.
  728.     
  729.     <cmd>.         Command-period will stop program execution.
  730.  
  731.     Print        Print graphics window if it's the front most window.
  732.             Only the graphics window can be printed.
  733.  
  734.  
  735.     CONVENTIONS
  736.  
  737.     EXPR        any expression that evaluates to a numeric value.
  738.     STRINGEXPR    a string expression.
  739.     VAR        a numeric variable.
  740.     STRINGVAR    a string variable. Name must end with a "$".
  741.     INTEGERVAR    a 16-bit variable. Name must end with a "%".
  742.     
  743.     All program lines must begin with a line number.  A line number
  744.     entered by itself will delete that program line. Using spaces
  745.     (indentation) between the line number and program statements is
  746.     legal.  Line numbers can be between 1 and 2147483647.
  747.     
  748.     Hexadecimal numbers can be entered by preceding them with
  749.     a "0x" as in 0x02ae, or by "&h" as in &h0172.
  750.     
  751.     Multiple statements may be given on one line, separated by
  752.     colons:
  753.  
  754.         10 INPUT X : PRINT X : STOP
  755.  
  756.  
  757.     DIAGNOSTICS
  758.  
  759.     Some errors can be caught by the user program using the "on error
  760.     goto" command. If no error trapping routine has been supplied
  761.     then program execution is terminated and a message is printed
  762.     with the corresponding line number.
  763.  
  764.     Graphics may require that the preferred memory requirements be
  765.     increased using the Finder "Get Info" dialog box.
  766.  
  767.  
  768.     AUTHORS
  769.     
  770.     David Gillespie wrote basic.p 1.0 and the p2c lib.
  771.     Ron Nicholson (rhn@netcom.com) added file i/o, graphics and
  772.     did the Unix, Macintosh and PowerMac port.  (1990-1995May)
  773.  
  774.     
  775.     BUGS
  776.  
  777.     Many.
  778.  
  779.     Can't CONTinue from an error inside a named SUB subroutine.
  780.     
  781.     PRINT USING format string doesn't recognize comma's or underscores.
  782.     
  783.     Integer VARs, like i%, don't work in FOR-NEXT statements. Integer
  784.     arrays can only have a dimension of one and will only work in
  785.     assignment (LET) statements.  All arithmetic on integer variables
  786.     is done using floating point arithmetic.
  787.  
  788.     Macintosh screen editing will only recognise the last line modified
  789.     before a RETURN or ENTER key.  The EDIT command and screen editing
  790.     are incompatible.
  791.  
  792.     There are several undocumented graphics and sprite commands
  793.     and keywords in the Macintosh port.  See the accompanying README
  794.     file.
  795.  
  796.  
  797.     Portions Copyright (C) 1989 Dave Gillespie
  798.     Copyright (C) 1994 Ronald H. Nicholson, Jr., All rights reserved.
  799.     "Applesoft" is a trademark of Apple Computer, Inc., etc.
  800.  
  801.